﻿using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Text;
using SharpSqlAnalyzer.pp.mediator;
using SharpSqlAnalyzer.pp.output;
using SharpSqlAnalyzer.pp.para;
using SharpSqlAnalyzer.pp.para.styleenums;
using SharpSqlAnalyzer.pp.print;
using SharpSqlAnalyzer.pp.processor;
using SharpSqlAnalyzer.pp.stmtformatter.builder;
using SharpSqlAnalyzer.pp.stmtformatter.builder.comm;
using SharpSqlAnalyzer.pp.stmtformatter.type;
using SharpSqlAnalyzer.pp.stmtformatter.type.comm;
using SharpSqlAnalyzer.pp.utils;
using SharpSqlAnalyzer.stmt;
using SharpSqlAnalyzer.stmt.mssql;

namespace SharpSqlAnalyzer.pp.stmtformatter
{
	// Token: 0x020001F9 RID: 505
	public class FormatterFactory
	{
		// Token: 0x060011AA RID: 4522 RVA: 0x00315C03 File Offset: 0x00313E03
		public static SelectStmtFormatter createSelectStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<SelectStmtFormatter>(opt, typeof(SelectStmtFormatter), new FormatterFactory.SelectStmtFormatterCreator());
		}

		// Token: 0x060011AB RID: 4523 RVA: 0x00315C1A File Offset: 0x00313E1A
		public static InsertStmtFormatter createInsertStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<InsertStmtFormatter>(opt, typeof(InsertStmtFormatter), new FormatterFactory.InsertStmtFormatterCreator());
		}

		// Token: 0x060011AC RID: 4524 RVA: 0x00315C31 File Offset: 0x00313E31
		public static DeleteStmtFormatter createDeleteStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<DeleteStmtFormatter>(opt, typeof(DeleteStmtFormatter), new FormatterFactory.DeleteStmtFormatterCreator());
		}

		// Token: 0x060011AD RID: 4525 RVA: 0x00315C48 File Offset: 0x00313E48
		public static UpdateStmtFormatter createUpdateStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<UpdateStmtFormatter>(opt, typeof(UpdateStmtFormatter), new FormatterFactory.UpdateStmtFormatterCreator());
		}

		// Token: 0x060011AE RID: 4526 RVA: 0x00315C5F File Offset: 0x00313E5F
		public static CreateTableStmtFormatter createCreateTableStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<CreateTableStmtFormatter>(opt, typeof(CreateTableStmtFormatter), new FormatterFactory.CreateTableStmtFormatterCreator());
		}

		// Token: 0x060011AF RID: 4527 RVA: 0x00315C76 File Offset: 0x00313E76
		public static DeclareStmtFormatter createDeclareStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<DeclareStmtFormatter>(opt, typeof(DeclareStmtFormatter), new FormatterFactory.DeclareStmtFormatterCreator());
		}

		// Token: 0x060011B0 RID: 4528 RVA: 0x00315C8D File Offset: 0x00313E8D
		public static ExecuteStmtFormatter createExecuteStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<ExecuteStmtFormatter>(opt, typeof(ExecuteStmtFormatter), new FormatterFactory.ExecuteStmtFormatterBuilderCreator());
		}

		// Token: 0x060011B1 RID: 4529 RVA: 0x00315CA4 File Offset: 0x00313EA4
		public static SetStmtFormatter createSetStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<SetStmtFormatter>(opt, typeof(SetStmtFormatter), new FormatterFactory.SetStmtFormatterCreator());
		}

		// Token: 0x060011B2 RID: 4530 RVA: 0x00315CBB File Offset: 0x00313EBB
		public static IfStmtFormatter createIfStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<IfStmtFormatter>(opt, typeof(IfStmtFormatter), new FormatterFactory.IfStmtFormatterCreator());
		}

		// Token: 0x060011B3 RID: 4531 RVA: 0x00315CD2 File Offset: 0x00313ED2
		public static PlsqlIfStmtFormatter createPlsqlIfStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<PlsqlIfStmtFormatter>(opt, typeof(PlsqlIfStmtFormatter), new FormatterFactory.PlsqlIfStmtFormatterCreator());
		}

		// Token: 0x060011B4 RID: 4532 RVA: 0x00315CE9 File Offset: 0x00313EE9
		public static PlsqlStmtFormatter createPlsqlStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<PlsqlStmtFormatter>(opt, typeof(PlsqlStmtFormatter), new FormatterFactory.PlsqlStmtFormatterCreator());
		}

		// Token: 0x060011B5 RID: 4533 RVA: 0x00315D00 File Offset: 0x00313F00
		public static GoStmtFormatter createGoStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<GoStmtFormatter>(opt, typeof(GoStmtFormatter), new FormatterFactory.GoStmtFormatterCreator());
		}

		// Token: 0x060011B6 RID: 4534 RVA: 0x00315D17 File Offset: 0x00313F17
		public static CompactModeStmtFormatter createCompactModeStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<CompactModeStmtFormatter>(opt, typeof(CompactModeStmtFormatter), new FormatterFactory.CompactModeStmtFormatterCreator());
		}

		// Token: 0x060011B7 RID: 4535 RVA: 0x00315D2E File Offset: 0x00313F2E
		public static ReturnStmtFormatter createReturnStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<ReturnStmtFormatter>(opt, typeof(ReturnStmtFormatter), new FormatterFactory.ReturnStmtFormatterCreator());
		}

		// Token: 0x060011B8 RID: 4536 RVA: 0x00315D45 File Offset: 0x00313F45
		public static CreateViewStmtFormatter createCreateViewStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<CreateViewStmtFormatter>(opt, typeof(CreateViewStmtFormatter), new FormatterFactory.CreateViewStmtFormatterCreator());
		}

		// Token: 0x060011B9 RID: 4537 RVA: 0x00315D5C File Offset: 0x00313F5C
		public static AlterTableStmtFormatter createAlterTableStatement(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<AlterTableStmtFormatter>(opt, typeof(AlterTableStmtFormatter), new FormatterFactory.IFormatterBuilderCreatorAnonymousInnerClass16());
		}

		// Token: 0x060011BA RID: 4538 RVA: 0x00315D74 File Offset: 0x00313F74
		public static E createFormatter<E>(GFmtOpt opt, Type clazz, FormatterFactory.IFormatterBuilderCreator creater) where E : AbstractStmtFormatter
		{
			string key = opt.sessionId + clazz.FullName;
			if (!FormatterFactory.formatter.ContainsKey(key))
			{
				Type typeFromHandle = typeof(FormatterFactory);
				lock (typeFromHandle)
				{
					if (!FormatterFactory.formatter.ContainsKey(key))
					{
						AbstractStmtFormatterBuilder abstractStmtFormatterBuilder = creater.create();
						abstractStmtFormatterBuilder.Option = opt;
						FormatterFactory.formatter[key] = abstractStmtFormatterBuilder.build();
					}
				}
			}
			return (E)((object)FormatterFactory.formatter[key]);
		}

		// Token: 0x060011BB RID: 4539 RVA: 0x00315E18 File Offset: 0x00314018
		public static void processStatement(GFmtOpt option, TCustomSqlStatement sql)
		{
			if (option.compactMode == TCompactMode.Cpmugly)
			{
				FormatterFactory.createCompactModeStmtFormatter(option).format(sql);
				return;
			}
			if (FormatterFactory.isNotNeedFormat(sql))
			{
				return;
			}
			if (sql is TSelectSqlStatement)
			{
				FormatterFactory.createSelectStmtFormatter(option).format((TSelectSqlStatement)sql);
				return;
			}
			if (sql is TInsertSqlStatement)
			{
				FormatterFactory.createInsertStmtFormatter(option).format((TInsertSqlStatement)sql);
				return;
			}
			if (sql is TDeleteSqlStatement)
			{
				FormatterFactory.createDeleteStmtFormatter(option).format((TDeleteSqlStatement)sql);
				return;
			}
			if (sql is TUpdateSqlStatement)
			{
				FormatterFactory.createUpdateStmtFormatter(option).format((TUpdateSqlStatement)sql);
				return;
			}
			if (sql is TCreateTableSqlStatement)
			{
				FormatterFactory.createCreateTableStmtFormatter(option).format((TCreateTableSqlStatement)sql);
				return;
			}
			if (sql is TMssqlDeclare)
			{
				FormatterFactory.createDeclareStmtFormatter(option).format((TMssqlDeclare)sql);
				return;
			}
			if (sql is TMssqlExecute)
			{
				FormatterFactory.createExecuteStmtFormatter(option).format((TMssqlExecute)sql);
				return;
			}
			if (sql is TStoredProcedureSqlStatement)
			{
				FormatterFactory.createPlsqlStmtFormatter(option).format((TStoredProcedureSqlStatement)sql);
				return;
			}
			if (sql is TMssqlSet)
			{
				FormatterFactory.createSetStmtFormatter(option).format((TMssqlSet)sql);
				return;
			}
			if (sql is TMssqlIfElse)
			{
				FormatterFactory.createIfStmtFormatter(option).format((TMssqlIfElse)sql);
				return;
			}
			if (sql is TMssqlGo)
			{
				FormatterFactory.createGoStmtFormatter(option).format((TMssqlGo)sql);
				return;
			}
			if (sql is TMssqlReturn)
			{
				FormatterFactory.createReturnStmtFormatter(option).format((TMssqlReturn)sql);
				return;
			}
			if (sql is TCreateViewSqlStatement)
			{
				FormatterFactory.createCreateViewStmtFormatter(option).format((TCreateViewSqlStatement)sql);
				return;
			}
			if (sql is TAlterTableStatement)
			{
				FormatterFactory.createAlterTableStatement(option).format((TAlterTableStatement)sql);
				return;
			}
			if (sql is TMergeSqlStatement)
			{
				FormatterFactory.createMergeSqlStatement(option).format((TMergeSqlStatement)sql);
				return;
			}
			if (sql is TIfStmt)
			{
				FormatterFactory.createPlsqlIfStmtFormatter(option).format((TIfStmt)sql);
				return;
			}
			FormatterFactory.createCommonStatement(option).format(sql);
		}

		// Token: 0x060011BC RID: 4540 RVA: 0x00315FF0 File Offset: 0x003141F0
		private static PlsqlBlockStmtFormatter createPlsqlBlockStmtFormatter(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<PlsqlBlockStmtFormatter>(opt, typeof(PlsqlBlockStmtFormatter), new FormatterFactory.PlsqlBlockStmtFormatterCreator());
		}

		// Token: 0x060011BD RID: 4541 RVA: 0x00316007 File Offset: 0x00314207
		private static MergeStmtFormatter createMergeSqlStatement(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<MergeStmtFormatter>(opt, typeof(MergeStmtFormatter), new FormatterFactory.MergeStmtFormatterBuilderCreator());
		}

		// Token: 0x060011BE RID: 4542 RVA: 0x0031601E File Offset: 0x0031421E
		private static CommonStmtFormatter createCommonStatement(GFmtOpt opt)
		{
			return FormatterFactory.createFormatter<CommonStmtFormatter>(opt, typeof(CommonStmtFormatter), new FormatterFactory.CommonStmtFormatterCreator());
		}

		// Token: 0x060011BF RID: 4543 RVA: 0x00316035 File Offset: 0x00314235
		public static bool isNotNeedFormat(TCustomSqlStatement sql)
		{
			return sql == null || (sql.startToken != null && FormatterFactory.isNotNeedFormat(sql.startToken));
		}

		// Token: 0x060011C0 RID: 4544 RVA: 0x00316054 File Offset: 0x00314254
		public static bool isNotNeedFormat(TSourceToken t)
		{
			if (t == null)
			{
				return false;
			}
			TSourceTokenList tokensBefore = t.TokensBefore;
			if (tokensBefore.size() > 0)
			{
				for (int i = 0; i < tokensBefore.size(); i++)
				{
					if (SourceTokenOperator.createNoFormatFlagToken().Equals(tokensBefore.get(i)))
					{
						return true;
					}
				}
			}
			return false;
		}

		// Token: 0x060011C1 RID: 4545 RVA: 0x003160A0 File Offset: 0x003142A0
		public static void processBlockStmt(GFmtOpt opt, TMssqlBlock stmt, TSourceToken ifToken)
		{
			TSourceToken startToken = stmt.startToken;
			TSourceToken endToken = stmt.endToken;
			if (startToken == null || endToken == null)
			{
				return;
			}
			int num = SourceTokenOperator.curColumnNumberVT(ifToken);
			if (opt.beStyleBlockLeftBEOnNewline)
			{
				num += opt.beStyleBlockLeftBEIndentSize;
				SourceTokenOperator.addBefore(opt, startToken, SourceTokenOperator.createReturnSourceToken());
				SourceTokenOperator.addBefore(opt, startToken, SourceTokenOperator.createWhitespaceSourceToken(num));
			}
			int num2 = SourceTokenOperator.curColumnNumberVT(ifToken) + (opt.beStyleBlockLeftBEOnNewline ? opt.beStyleBlockLeftBEIndentSize : opt.beStyleBlockRightBEIndentSize);
			SourceTokenOperator.addBefore(opt, endToken, SourceTokenOperator.createReturnSourceToken());
			SourceTokenOperator.addBefore(opt, endToken, SourceTokenOperator.createWhitespaceSourceToken(num2));
			TStatementList bodyStatements = stmt.BodyStatements;
			if (bodyStatements != null && bodyStatements.size() > 0)
			{
				int length = num2 + opt.beStyleBlockIndentSize;
				TSourceToken startToken2 = bodyStatements.get(0).startToken;
				if (startToken2 != null)
				{
					SourceTokenOperator.addBefore(opt, startToken2, SourceTokenOperator.createReturnSourceToken());
					SourceTokenOperator.addBefore(opt, startToken2, SourceTokenOperator.createWhitespaceSourceToken(length));
				}
			}
			AllStmtsFormatter.processEmptyLine(bodyStatements, opt, true);
			if (bodyStatements != null && bodyStatements.size() > 0)
			{
				for (int i = 0; i < bodyStatements.size(); i++)
				{
					TCustomSqlStatement sql = bodyStatements.get(i);
					FormatterFactory.processStatement(opt, sql);
				}
			}
		}

		// Token: 0x060011C2 RID: 4546 RVA: 0x003161BC File Offset: 0x003143BC
		public static string pp(TGSharpSqlParser parser, GFmtOpt option)
		{
			MemoryStream memoryStream = new MemoryStream();
			StreamWriter streamWriter = new StreamWriter(memoryStream);
			IPrinter printer = PrinterFactory.createTextPrinter(streamWriter);
			FormatterFactory.createAllStmtsFormatter(option).beforeFormat(parser.sqlstatements);
			for (int i = 0; i < parser.sqlstatements.size(); i++)
			{
				TCustomSqlStatement sql = parser.sqlstatements.get(i);
				FormatterFactory.processStatement(option, sql);
			}
			if (parser.sqlstatements != null && parser.sqlstatements.size() > 0)
			{
				FormatterFactory.createAllStmtsFormatter(option).doFormat(parser.sqlstatements);
				FormatterFactory.createAllStmtsFormatter(option).afterFormat(parser.sqlstatements);
				if (FormatterFactory.outputConfig == null)
				{
					FormatterFactory.outputConfig = OutputConfigFactory.getOutputConfig(option, parser.DbVendor);
				}
				printer.OutputConfig = FormatterFactory.outputConfig;
				printer.print(parser.sqlstatements.get(0).startToken.container);
			}
			FormatterFactory.clearAllObject(option.sessionId);
			streamWriter.Close();
			return Encoding.UTF8.GetString(memoryStream.ToArray());
		}

		// Token: 0x17000343 RID: 835
		// (get) Token: 0x060011C3 RID: 4547 RVA: 0x003162B2 File Offset: 0x003144B2
		// (set) Token: 0x060011C4 RID: 4548 RVA: 0x003162B9 File Offset: 0x003144B9
		public static OutputConfig OutputConfig
		{
			get
			{
				return FormatterFactory.outputConfig;
			}
			set
			{
				FormatterFactory.outputConfig = value;
			}
		}

		// Token: 0x060011C5 RID: 4549 RVA: 0x003162C1 File Offset: 0x003144C1
		public static AllStmtsFormatter createAllStmtsFormatter(GFmtOpt option)
		{
			return AllStmtsFormatterBuilder.create(option);
		}

		// Token: 0x060011C6 RID: 4550 RVA: 0x003162C9 File Offset: 0x003144C9
		public static void clearAllObject(string sessionId)
		{
			FormatterFactory.clear(sessionId);
			ProcessorFactory.clear(sessionId);
			MediatorFactory.clear(sessionId);
		}

		// Token: 0x060011C7 RID: 4551 RVA: 0x003162E0 File Offset: 0x003144E0
		public static void clear(string sessionId)
		{
			object obj = FormatterFactory.@object;
			lock (obj)
			{
				IList<string> list = new List<string>();
				foreach (string text in FormatterFactory.formatter.Keys)
				{
					if (text.StartsWith(sessionId, StringComparison.Ordinal))
					{
						list.Add(text);
					}
				}
				foreach (string key in list)
				{
					FormatterFactory.formatter.Remove(key);
				}
			}
		}

		// Token: 0x040013CA RID: 5066
		private static volatile IDictionary<string, AbstractStmtFormatter> formatter = new ConcurrentDictionary<string, AbstractStmtFormatter>();

		// Token: 0x040013CB RID: 5067
		private static object @object = new object();

		// Token: 0x040013CC RID: 5068
		private static OutputConfig outputConfig;

		// Token: 0x02000438 RID: 1080
		private class SelectStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002966 RID: 10598 RVA: 0x0033E43D File Offset: 0x0033C63D
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new SelectStmtFormatterBuilder();
			}
		}

		// Token: 0x02000439 RID: 1081
		private class InsertStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002968 RID: 10600 RVA: 0x0033E44C File Offset: 0x0033C64C
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new InsertStmtFormatterBuilder();
			}
		}

		// Token: 0x0200043A RID: 1082
		private class DeleteStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x0600296A RID: 10602 RVA: 0x0033E45B File Offset: 0x0033C65B
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new DeleteStmtFormatterBuilder();
			}
		}

		// Token: 0x0200043B RID: 1083
		private class UpdateStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x0600296C RID: 10604 RVA: 0x0033E46A File Offset: 0x0033C66A
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new UpdateStmtFormatterBuilder();
			}
		}

		// Token: 0x0200043C RID: 1084
		private class CreateTableStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x0600296E RID: 10606 RVA: 0x0033E479 File Offset: 0x0033C679
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new CreateTableStmtFormatterBuilder();
			}
		}

		// Token: 0x0200043D RID: 1085
		private class DeclareStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002970 RID: 10608 RVA: 0x0033E488 File Offset: 0x0033C688
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new DeclareStmtFormatterBuilder();
			}
		}

		// Token: 0x0200043E RID: 1086
		private class ExecuteStmtFormatterBuilderCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002972 RID: 10610 RVA: 0x0033E497 File Offset: 0x0033C697
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new ExecuteStmtFormatterBuilder();
			}
		}

		// Token: 0x0200043F RID: 1087
		private class SetStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002974 RID: 10612 RVA: 0x0033E4A6 File Offset: 0x0033C6A6
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new SetStmtFormatterBuilder();
			}
		}

		// Token: 0x02000440 RID: 1088
		private class IfStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002976 RID: 10614 RVA: 0x0033E4B5 File Offset: 0x0033C6B5
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new IfStmtFormatterBuilder();
			}
		}

		// Token: 0x02000441 RID: 1089
		private class PlsqlIfStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002978 RID: 10616 RVA: 0x0033E4C4 File Offset: 0x0033C6C4
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new PlsqlIfStmtFormatterBuilder();
			}
		}

		// Token: 0x02000442 RID: 1090
		private class PlsqlStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x0600297A RID: 10618 RVA: 0x0033E4D3 File Offset: 0x0033C6D3
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new PlsqlStmtFormatterBuilder();
			}
		}

		// Token: 0x02000443 RID: 1091
		private class GoStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x0600297C RID: 10620 RVA: 0x0033E4E2 File Offset: 0x0033C6E2
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new GoStmtFormatterBuilder();
			}
		}

		// Token: 0x02000444 RID: 1092
		private class CompactModeStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x0600297E RID: 10622 RVA: 0x0033E4F1 File Offset: 0x0033C6F1
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new CompactModeStmtFormatterBuilder();
			}
		}

		// Token: 0x02000445 RID: 1093
		private class ReturnStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002980 RID: 10624 RVA: 0x0033E500 File Offset: 0x0033C700
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new ReturnStmtFormatterBuilder();
			}
		}

		// Token: 0x02000446 RID: 1094
		private class CreateViewStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002982 RID: 10626 RVA: 0x0033E50F File Offset: 0x0033C70F
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new CreateViewStmtFormatterBuilder();
			}
		}

		// Token: 0x02000447 RID: 1095
		private class IFormatterBuilderCreatorAnonymousInnerClass16 : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002984 RID: 10628 RVA: 0x0033E51E File Offset: 0x0033C71E
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new AlterTableStmtFormatterBuilder();
			}
		}

		// Token: 0x02000448 RID: 1096
		public interface IFormatterBuilderCreator
		{
			// Token: 0x06002985 RID: 10629
			AbstractStmtFormatterBuilder create();
		}

		// Token: 0x02000449 RID: 1097
		private class PlsqlBlockStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002987 RID: 10631 RVA: 0x0033E52D File Offset: 0x0033C72D
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new PlsqlBlockStmtFormatterBuilder();
			}
		}

		// Token: 0x0200044A RID: 1098
		private class MergeStmtFormatterBuilderCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x06002989 RID: 10633 RVA: 0x0033E53C File Offset: 0x0033C73C
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new MergeStmtFormatterBuilder();
			}
		}

		// Token: 0x0200044B RID: 1099
		private class CommonStmtFormatterCreator : FormatterFactory.IFormatterBuilderCreator
		{
			// Token: 0x0600298B RID: 10635 RVA: 0x0033E54B File Offset: 0x0033C74B
			public virtual AbstractStmtFormatterBuilder create()
			{
				return new CommonStmtFormatterBuilder();
			}
		}
	}
}
